package DAO;

import AccesoBD.AccesoBaseDatos;
import Dominio.AreaConcentracion;
import Dominio.Asignatura;
import Dominio.AsignaturaOptativaAlumno;
import Dominio.AsignaturaOfertaAcademica;
import Dominio.AsignaturaOptativa;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

public class DAOAsignaturasOptativasAlumno {
    private String TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO = "asignaturas_optativas_alumno";
    private String COLUMNA_CLAVE_ASIGNATURA_OPTATIVA_ALUMNO = "clv_asignaturas_optativas_alumno";
    private String COLUMNA_CLAVE_RELACION_ALUMNO_PE = "clv_rel_alumno_pe";
    private String COLUMNA_CLAVE_ASIGNATURA_OPTATIVA = "clv_optativa";
    private String COLUMNA_ESTADO_ASIGNATURA = "estado_asignatura";
    private AccesoBaseDatos acceso;
    private Connection conexion = null;
    
    public static final int ESTADO_APROVADA = 0;
    public static final int ESTADO_RECURSABLE = 1; 
    public static final int ESTADO_NO_CURSABLE = 2;   
    
    public DAOAsignaturasOptativasAlumno(){
        acceso = new AccesoBaseDatos();
        conexion = acceso.abrirConexion();
    }
    
    public void cerrarConexionAAsignaturaOptativaAlumno() {
        acceso.cerrarConexion(conexion);
    }
    
    public void registrarAsignaturaOptativaAlumno(int claveRelacionAlumnoPE, int claveOptativa, int estadoAsignatura){
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            String queryInsertar = "INSERT INTO " + TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO + " ("
                    + COLUMNA_CLAVE_RELACION_ALUMNO_PE +","
                    + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA +","
                    + COLUMNA_ESTADO_ASIGNATURA
                    + ") VALUES ('"
                    +claveRelacionAlumnoPE+"','"
                    +claveOptativa+"','"
                    +estadoAsignatura+"')";
            sentencia.executeUpdate(queryInsertar);
        } catch (SQLException ex) {
            System.out.println("Ocurrió un problema al tratar de registrar la Asignatura");
        }
    }
    
    public AsignaturaOptativaAlumno obtenerAsignaturaAlumno(int claveAsignaturaOptativaAlumno){
        String queryBusqueda = "SELECT * FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO+ " WHERE " + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA_ALUMNO + " = " + claveAsignaturaOptativaAlumno;
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            resultado.first();
            if(resultado.getRow() != 0){
                AsignaturaOptativaAlumno asignatura = new AsignaturaOptativaAlumno();
                asignatura.setClaveAsignaturaOptativaAlumno(resultado.getInt(1));
                asignatura.setClaveRelacionAlumnoPE(resultado.getInt(2));
                asignatura.setClaveOptativa(resultado.getInt(3));
                asignatura.setEstado(resultado.getInt(4));
                return asignatura;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
            return null;
        }
    }
    
    public AsignaturaOptativaAlumno obtenerAsignaturaAlumno(int claveRelacionAlumnoPE, int claveOptativa){
        String queryBusqueda = "SELECT * FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO
                + " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = '" + claveRelacionAlumnoPE +"' AND "
                + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA + " = '" + claveOptativa +"'";
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            resultado.first();
            if(resultado.getRow() != 0){
                AsignaturaOptativaAlumno asignatura = new AsignaturaOptativaAlumno();
                asignatura.setClaveAsignaturaOptativaAlumno(resultado.getInt(1));
                asignatura.setClaveRelacionAlumnoPE(resultado.getInt(2));
                asignatura.setClaveOptativa(resultado.getInt(3));
                asignatura.setEstado(resultado.getInt(4));
                return asignatura;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
            return null;
        }
    }
    
    public AsignaturaOptativaAlumno obtenerAsignaturaAlumno(int claveInfoAlumno, int claveProgramaEducativo, int claveOptativa){
        DAORelacionAlumnoProgramaEducativo daoAPE = new DAORelacionAlumnoProgramaEducativo();
        int claveRelacionAlumnoPE = daoAPE.obtenerClaveRelacion(claveInfoAlumno, claveProgramaEducativo);
        daoAPE.cerrarConexionARelacionAlumnoProgramaEducativo();
        if(claveRelacionAlumnoPE==-1){
            return null;
        }
        String queryBusqueda = "SELECT * FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO
                + " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = '" + claveRelacionAlumnoPE +"' AND "
                + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA + " = '" + claveOptativa +"'";
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            resultado.first();
            if(resultado.getRow() != 0){
                AsignaturaOptativaAlumno asignatura = new AsignaturaOptativaAlumno();
                asignatura.setClaveAsignaturaOptativaAlumno(resultado.getInt(1));
                asignatura.setClaveRelacionAlumnoPE(resultado.getInt(2));
                asignatura.setClaveOptativa(resultado.getInt(3));
                asignatura.setEstado(resultado.getInt(4));
                return asignatura;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
            return null;
        }
    }
    
    public void eliminarAsignaturaAlumno(int claveAsignaturaOptativaAlumno) {
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            String deleteQuery = "DELETE FROM " + TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO + " WHERE " + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA_ALUMNO + " = '" + claveAsignaturaOptativaAlumno + "'";
            sentencia.executeUpdate(deleteQuery);
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
        }
    }
    
    public void actualizarAsignaturaAlumno(int claveAsignaturaOptativaAlumno, int nuevaClaveRelacionAlumnoPE, int nuevaClaveOptativa, int nuevoEstadoAsignatura) {
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            String queryUpdate = "UPDATE " + TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO + " SET "
                    + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = '" + nuevaClaveRelacionAlumnoPE + "' ,"
                    + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA + " = '" + nuevaClaveOptativa +"' ,"
                    + COLUMNA_ESTADO_ASIGNATURA + " = '" + nuevoEstadoAsignatura +"' "
                    + " WHERE " + COLUMNA_CLAVE_ASIGNATURA_OPTATIVA_ALUMNO + " = '" + claveAsignaturaOptativaAlumno + "'";
            sentencia.executeUpdate(queryUpdate);
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
        }
    }
    
    /**
     * Metodo que retorna las Asignaturas correspondientes a cierto estado y
     * que se encuentran dentro de la reticula academica
     * @param claveInfoAlumno
     * @param claveProgramaEducativo
     * @param estado
     * @return 
     */
    public ArrayList<Asignatura> obtenerAsignaturasPorEstado(int claveInfoAlumno, int claveProgramaEducativo, int estado){
        DAORelacionAlumnoProgramaEducativo daoAPE = new DAORelacionAlumnoProgramaEducativo();
        int claveRelacionAlumnoPE = daoAPE.obtenerClaveRelacion(claveInfoAlumno, claveProgramaEducativo);
        daoAPE.cerrarConexionARelacionAlumnoProgramaEducativo();
        if(claveRelacionAlumnoPE==-1){
            return null;
        }
        String queryBusqueda = "SELECT "+COLUMNA_CLAVE_ASIGNATURA_OPTATIVA+" FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO
                + " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = " + claveRelacionAlumnoPE +" AND "
                + COLUMNA_ESTADO_ASIGNATURA + " = '" + estado +"'";
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            DAOAsignaturaOptativa daoO = new DAOAsignaturaOptativa();
            ArrayList<AsignaturaOptativa> optativasPorPE = daoO.obtenerOptativasProgramaEducativo(claveProgramaEducativo);
            ArrayList<Asignatura> asignaturas = new ArrayList<Asignatura>();
            while(resultado.next()){
                int claveAsignatura = resultado.getInt(1);
                for(int i = 0; i<optativasPorPE.size(); i++){
                    if(optativasPorPE.get(i).getClave_asignatura()==claveAsignatura){
                        asignaturas.add(optativasPorPE.get(i));
                        break;
                    }
                }
            }
            resultado.close();
            if(asignaturas.size()>0){
                return asignaturas;
            } else {
                return null;
            }
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
            return null;
        }
    }
    
    public ArrayList<AsignaturaOfertaAcademica> obtenerAsignaturasPorEstadoOfertada(String claveOferta, int claveInfoAlumno, int claveProgramaEducativo, int estado){
        //Para obtener las asignaturas Cursables(primera vez) se envia -1
        DAOOfertaAcademica daoOA = new DAOOfertaAcademica();
        ArrayList<AsignaturaOfertaAcademica> asignaturasOfertadas = daoOA.buscarOfertaAcademica(claveOferta).getAsignaturas();
        daoOA.cerrarConexionAOferta();
        ArrayList<Asignatura> asignaturasOptativas = obtenerAsignaturasPorEstado(claveInfoAlumno, claveProgramaEducativo, estado);
        ArrayList<AsignaturaOfertaAcademica> resultado = new ArrayList<AsignaturaOfertaAcademica>();
        if(asignaturasOptativas==null){
            return new ArrayList<AsignaturaOfertaAcademica>();
        }
        for(int i=0; i<asignaturasOptativas.size(); i++){
            for(int j=0; j<asignaturasOfertadas.size(); j++){
                if(asignaturasOptativas.get(i).getClave_asignatura()==asignaturasOfertadas.get(j).getClaveAsignatura()){
                    resultado.add(asignaturasOfertadas.get(j));
                    break;
                }
            }
        }
        return resultado;
    }

    public ArrayList<AsignaturaOfertaAcademica> obtenerAsignaturasCursablesOfertada(String claveOferta, int claveInfoAlumno, int claveProgramaEducativo){
        ArrayList<AsignaturaOfertaAcademica> resultado = obtenerAsignaturasPorEstadoOfertada(claveOferta, claveInfoAlumno, claveProgramaEducativo, -1);
        return resultado;
    }    
       
    public ArrayList<AsignaturaOfertaAcademica> obtenerAsignaturasPorEstadoOfertada2(ArrayList<AsignaturaOfertaAcademica> asignaturasOfertadas, /*String claveOferta,*/ int claveInfoAlumno, int claveProgramaEducativo, int estado){
        
        ArrayList<Asignatura> asignaturasOptativas = obtenerAsignaturasPorEstado(claveInfoAlumno, claveProgramaEducativo, estado);
        ArrayList<AsignaturaOfertaAcademica> resultado = new ArrayList<AsignaturaOfertaAcademica>();
        if(asignaturasOptativas==null){
            return new ArrayList<AsignaturaOfertaAcademica>();
        }
        
        /*
        for(int i=0; i<asignaturasOptativas.size(); i++){
            for(int j=0; j<asignaturasOfertadas.size(); j++){
                if(asignaturasOptativas.get(i).getClave_asignatura()==asignaturasOfertadas.get(j).getClaveAsignatura()){
                    resultado.add(asignaturasOfertadas.get(j));
                    break;
                }
            }
        }
        */
        
        
        
        for(int j=0; j<asignaturasOfertadas.size(); j++){
            for(int i=0; i<asignaturasOptativas.size(); i++){
                if(asignaturasOptativas.get(i).getClave_asignatura()==asignaturasOfertadas.get(j).getClaveAsignatura()){
                    resultado.add(asignaturasOfertadas.get(j));
                    break;
                }    
            } 
        }
        
        return resultado;
    }
    
    public ArrayList<AsignaturaOfertaAcademica> obtenerAsignaturasPorEstadoOfertada3(ArrayList<AsignaturaOfertaAcademica> asignaturasOfertadas, int claveInfoAlumno, int claveProgramaEducativo, int estado){
        ArrayList<AsignaturaOfertaAcademica> listaAsignaturasOptativasOfertaAcademica = new ArrayList<AsignaturaOfertaAcademica>(); 
        
        try {
            DAORelacionAlumnoProgramaEducativo daoAPE = new DAORelacionAlumnoProgramaEducativo();
            int claveRelacionAlumnoPE = daoAPE.obtenerClaveRelacion(claveInfoAlumno, claveProgramaEducativo);
            daoAPE.cerrarConexionARelacionAlumnoProgramaEducativo();
            
            String queryBusqueda = "SELECT * FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO
                    + " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = '" + claveRelacionAlumnoPE +"' AND "
                    + COLUMNA_ESTADO_ASIGNATURA + " = '" + estado +"'";        
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            
            ArrayList<Integer> listaClavesAsignaturasOptativas = new ArrayList<Integer>();
            
            while(resultado.next()) {
                int claveAsignaturaOptativa = resultado.getInt(3);
                listaClavesAsignaturasOptativas.add(claveAsignaturaOptativa);        
            }
            
            ArrayList<AsignaturaOptativa> listaAsignaturasOptativas = new ArrayList<AsignaturaOptativa>();
            
            for(int i = 0; i < listaClavesAsignaturasOptativas.size(); i++) {
                int claveAsignaturaOptativa = listaClavesAsignaturasOptativas.get(i);
                
                DAOAsignaturaOptativa daoAsignaturaOptativa = new DAOAsignaturaOptativa();
                AsignaturaOptativa asignaturaOptativa = daoAsignaturaOptativa.obtenerAsignaturaOptativa(claveAsignaturaOptativa);
                daoAsignaturaOptativa.cerrarConexionAAsignaturaOptativa();
                
                listaAsignaturasOptativas.add(asignaturaOptativa); 
            }
                                               
            for(int j=0; j<asignaturasOfertadas.size(); j++){
                for(int i=0; i<listaAsignaturasOptativas.size(); i++){
                    if(listaAsignaturasOptativas.get(i).getAsignatura().getClave_asignatura() == asignaturasOfertadas.get(j).getClaveAsignatura()){
                        listaAsignaturasOptativasOfertaAcademica.add(asignaturasOfertadas.get(j));
                        break;
                    }    
                } 
            }
            
            
        } catch (SQLException ex) {
            Logger.getLogger(DAOAsignaturasOptativasAlumno.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        return listaAsignaturasOptativasOfertaAcademica;
    }
    
    public int obtenerNumeroDeAsignaturasOptativasDelAlumno(int claveRelacionAlumnoPE) {
        int numeroDeAsignaturas = 0;
        
        String queryBusqueda = "SELECT * FROM "+TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO+ " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = " + claveRelacionAlumnoPE;
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            ResultSet resultado = sentencia.executeQuery(queryBusqueda);
            
            while(resultado.next()){
                numeroDeAsignaturas++;
           } 
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());       
        }
        
        return numeroDeAsignaturas;
    }    
    
    public void eliminarAsignaturasDelAlumno(int claveRelacionAlumnoPE) {
        try {
            Statement sentencia = acceso.crearSentenciaBD(conexion);
            String deleteQuery = "DELETE FROM " + TABLA_ASIGNATURAS_OPTATIVAS_ALUMNO + " WHERE " + COLUMNA_CLAVE_RELACION_ALUMNO_PE + " = '" + claveRelacionAlumnoPE + "'";
            sentencia.executeUpdate(deleteQuery);
        } catch (SQLException ex) {
            System.err.println("Problemas de SQL:\n"+ex.toString());
        }
    }
    
}
